打开邮箱
mailto:feedback@58pic.com <a href="mailto:feedback@58pic.com">feedback@58pic.com</a>
qq
javascript:window.open('http://wpa.b.qq.com/cgi/wpa.php?ln=2&uin=4009987011&eid=218808P8z8p8y8z8R8x8p&o=www.58pic.com&q=7&ref='+document.location, '_blank', 'height=544, width=644,toolbar=no,scrollbars=no,menubar=no,status=no');
$.ajaxFileUpload({
			type: "POST",
		        url: "/feedbackImg",
		        secureuri: false,
		        data:{ext:ext},//传参数
		        fileElementId: "pic",
		        success: function (data) {
		            data = JSON.parse($(data).text());
		            $(".imgDiv").show();
		            $(".productImage").attr("src", data.imgUrl);
		            $(".productImage").attr("data", data.filePath);
		            $("#but").text("上传");
		            $("#but").attr("onclick", "uploadpic()");
		        },
		        error: function (data, status, e) {
		            alert(data + "," + status + "," + e);
		        }
		    });
1,2 调试抽奖页面，方法和变量是全局，$({调用方法})
localhost/weixin-cbg/award/awardInfo
1.调试抽奖页面
2.修改在线商店的主页样式
3.熟悉新版在线商店并修改购物车 规格一栏的样式及在售商品的样式


变量的作用域

声明的变量与调用的方法在同一层上 显示的变量时同一个
（1）函数的调用
var a = 1;
var fn = function() {
    alert(a);//a=1;[3]
}

var fn2 = function(callback) {
    var a = 2;
    callback();//调用传过来的函数[2]
}
fn2(fn);//调用fn2函数  [1]

1


（2）匿名函数
var a = 1;
var fn = function() {
    alert(a);// a=1; [3]
};
(function(callback) {
    var a = 2;
    callback();//调用参数那个函数[2]
})(fn);//fn 是传过来的参数 参数是一个函数 [1]

1


var a = 1;
var fn = function() { // [2]
    var a = 2;
    return function() {
        alert(a); //a=2 [3]
    }
}
var f = fn();
f(); //调用f [1]  fn()() == var f = fn(); f(); 
2


函数返回一个内部函数


var add = function(x){  //声明一个函数表达式
    var sum = 1;  
//在函数表达式内部有一个求和的内部函数
    var tmp = function(x){  
        sum = sum + x; //求和  
        return tmp;  
    }  
//构建一个函数体的toString()函数
    tmp.toString = function(){  
        return sum;  
    }  
    return tmp; //返回的是一个函数体，如果该函数体有toString()方法，则会调用函数体的toString()方法  
} ;
alert(add(1)(2)(3)) //  add(1)(2)(3)  add(1)调用的是外层函数体 add(1)(2) 调用的是内层函数体


demo
function a(str){
    console.log("string:"+str);
    return function(obj1,obj2){
        console.log(obj1+"----"+obj2);    
        return obj1+obj2;
    }
}
var c1 = a("pro");//创建函数 只会调用外层函数体对象
c1(1,2);//调用函数 可以调用内层函数体


在函数内返回一个已经声明的函数，其实是调用已经声明的函数
function infun(obj1,obj2){
    console.log(obj1+"----"+obj2);
    return obj1 + obj2;
}
function b(pro){
    console.log("pro:"+pro);
    var obj1=1,obj2=2;
    return infun(obj1,obj2);
}
var c1 = b("pro");





参考 http://www.cnblogs.com/pssp/p/5216085.html
// this 的指向 
一、 this的指向在函数定义的时候是确定不了的，只有函数执行的时候才能确定this到底指向谁，
实际上this的最终指向的是那个调用它的对象
（1）
function a(){
    var user = "追梦子";
    console.log(this.user); //undefined
    console.log(this); //Window
}
a(); == window.a()

在这里的函数a实际上是被Window对象所点出来的，所以this指向window
（2）
var o = {
    user:"追梦子",
    fn:function(){
        console.log(this.user);  //追梦子
    }
}
o.fn();

o调用的fn函数 所以this指向的是o 谁调用指向谁

问题：（3）
var o = {
    user:"追梦子",
    fn:function(){
        console.log(this.user); //追梦子
    }
}
window.o.fn(); //为什么没有指向window
window是js中的全局对象，我们创建的变量实际上是给window添加属性，所以这里可以用window点o对象。


var o = {
    a:10,
    b:{
        a:12,
        fn:function(){
            console.log(this.a); //12
        }
    }
}
o.b.fn();
//this指向的是b
如果一个函数中有this，但是他没有被上一级对象所调用，那么this指向的是window
如果一个函数中有this，这个函数有被上一级的对象所调用，那么this指向的就是上一级的对象
如果一个函数中有this，，这个函数中包含多个对象，尽管这个函数是被最外层的对象所调用，this指向的是它上一级的对象
例3
var o = {
    a:10,
    b:{
        // a:12,
        fn:function(){
            console.log(this.a); //undefined this指向的是b
        }
    }
}
o.b.fn();

尽管对象b中没有属性a，这个this指向的也是对象b，因为this只会指向他的上一级对象，不管这个对象中有没有this要的东西
例4
var o = {
    a:10,
    b:{
        a:12,
        fn:function(){
            console.log(this.a); //undefined
            console.log(this); //window
        }
    }
}
var j = o.b.fn;
j();//window.j()
j()==function(){
   console.log(this.a);//未声明a undefined
   console.log(this);//window
}

这里this指向的是window
this永远指向的是最后调用它的对象，也就是看它执行的时候是谁调用的，例子4中虽然函数fn是被对象b所引用，
但是在将fn赋值给变量j的时候并没有执行所以最终指向的是window，这和例子3是不一样的，例子3是直接执行了fn。

构造函数版this


function Fn(){
    this.user = "追梦子";
}
var a = new Fn();
console.log(a.user); //追梦子

这里之所以对象a可以点出函数Fn里面的user是因为new关键字可以改变this的指向，将这个this指向对象a，a之所以是对象，
因为通过new关键字相当于创建一个对象实例 将Fn赋值一份给a，但并没有调用，调用这个函数Fn的是对象a，this指向的是
对象a

this碰到return
function fn(){
   this.user = '追梦子';
   return {};   
}
var a = new fn;
console.log(a.user);//undefined


function fn()  
{  
    this.user = '追梦子';  
    return function(){};
}
var a = new fn;  
console.log(a.user); //undefined


function fn()  
{  
    this.user = '追梦子';  
    return 1;
}
var a = new fn;  
console.log(a.user); //追梦子


function fn()  
{  
    this.user = '追梦子';  
    return undefined;
}
var a = new fn;  
console.log(a.user); //追梦子

如果返回值是一个对象，那么this指向的就是那个返回的对象，如果返回值不是一个对象那么this还是指向函数的实例

function fn()  
{  
    this.user = '追梦子';  
    return undefined;
}
var a = new fn;  
console.log(a); //fn {user: "追梦子"}

在严格版中的默认的this不再是window，而是undefined。
new操作符会改变函数this的指向问题。


function fn(){
    this.num = 1;
}
var a = new fn();
console.log(a.num); //1

new关键字会创建一个空的对象，然后会自动调用一个函数apply方法，将this指向这空对象，这样的话函数内部的this就会被这个
空对象，这样的话函数内部的this就会被这个空的对象替代。

创建函数
通过构造器的方式来创建函数，最后一个参数为函数体其他为形参

new Function{'a','b','alert(a)'};
相当于 function anonymous(a,b){
           alert(a);
       }

function foo(){
    var a = 10;
    console.log(a);
}
newFunction('say',foo + 'foo();console.log(say)')('hello foo');
// 10  hello foo

相当于

function anonymous(say){
    function foo(){
        var a = 10;
        console.log(a);
    }foo(); // 10
    console.log(say); 
}

实现json字符串转对象

var json = '{a:123,b:456}';
new Function('return'+json)();
//object {a:123,b:456}

重载运算符
function calc(num1,num2,operator){
    return new Function('return'+num1+operator+num2)();
}
console.log(calc(2,3,'+'));
console.log(calc(5,3,'-'));

还可以将返回的函数作为构造器来创建对象
new newFunction();

执行函数
函数名加()可以执行一个函数
function foo(){
    console.log(123);
}
foo();

匿名函数的来历
function(){}//Uncaught SyntaxError: Unexpected token
不支持直接这么写，需要将函数改成一段表达式，将函数进行运算就成表达式了
''+function(){console.log(5)}; //"function(){console.log(5)}"
执行时 加()
''+function(){console.log(5)}();//5

优雅的格式 (function(){console.log(123)}());//123
callee的意义就在于当我们使用匿名函数时可以去调用函数本身

var a = 0;
(function(){
    if(a > 3) return;
    console.log(++a);
    arguments.callee();
}());
// 1
// 2
// 3
// 4

匿名函数与闭包
var abc = function(x,y){
    return x+y;
}
alert(abc(2,3));//5
(function(x,y){return x+y;})(2,3)
小括号能把我们的表达式组合分块，并且每一块，也就是每一对小括号，都有一个返回值。
这个返回值实际上也就是小括号中表达式的返回值。所以，当我们用一对小括号把匿名函数括起来的时候，
实际上小括号对返回的，就是一个匿名函数的Function对象。
因此，小括号对加上匿名函数就如同有名字的函数般被我们取得它的引用位置了。
所以如果在这个引用变量后面再加上参数列表，就会实现普通函数的调用形式。

匿名函数可以理解为括号表达式返回的函数对象，然后就可以对这个函数对象作正常的参数列表调用了


闭包是指某种程序语言中的代码块允许一级函数存在并且在一级函数中所定义的自由变量能不被释放，
直到一级函数被释放前，一级函数外也能应用这些未释放的自由变量。



 location.protocol：协议名
    location.username：用户名
    location.password：密码
    location.hostname：主机名
    location.port：端口号
    location.host：主机名和端口号
    location.pathname：路径
    location.search：查询串
    location.hash：书签名











